home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 9 / Night Owl CD-ROM (NOPV9) (Night Owl Publisher) (1993).ISO / 001a / seyon213.tz / seyon213 / seyon / SeGeneric.c < prev    next >
C/C++ Source or Header  |  1993-03-26  |  6KB  |  286 lines
  1.  
  2. /*
  3.  * This file is part of the Seyon, Copyright (c) 1992-1993 by Muhammad M.
  4.  * Saggaf. All rights reserved.
  5.  *
  6.  * See the file COPYING (1-COPYING) or the manual page seyon(1) for a full
  7.  * statement of rights and permissions for this program.
  8.  */
  9.  
  10. #include "config.h"
  11.  
  12. #include <stdio.h>
  13. #ifndef NOSTDHDRS
  14. #include <stdlib.h>
  15. #endif
  16. #include <unistd.h>
  17. #include <signal.h>
  18. #include <setjmp.h>
  19. #include <errno.h>
  20. #include <sys/types.h>
  21. #include <sys/time.h>
  22. #include <ctype.h>
  23. #include <math.h>
  24.  
  25. #include "SeDecl.h"
  26.  
  27. void
  28. ReadCommentedFile(fp, line)
  29.      FILE           *fp;
  30.      char           *line[];
  31. {
  32.   char            buffer[REG_BUF + 1],
  33.                  *bufPtr,
  34.                  *ptr;
  35.   int             i;
  36.  
  37.   for (i = 0; i < MAX_ENT && fgets(buffer, REG_BUF, fp) != NULL;) {
  38.  
  39.     /*Strip newline character from end of string*/
  40.     buffer[strlen(buffer) - 1] = '\0';
  41.  
  42.     /*Remove leading and trailing spaces*/
  43.     bufPtr = SSpc(buffer);
  44.  
  45.     /*Ignore this line if it is empty or starts with a comment*/
  46.     if (bufPtr[0] == '\0' || bufPtr[0] == '#')
  47.       continue;
  48.  
  49.     /*Ignore trailing comments*/
  50.     if ((ptr = (char *) strrchr(bufPtr, '#')) != NULL)
  51.       *ptr = '\0';
  52.  
  53.     line[i++] = XtNewString(bufPtr);
  54.   }
  55.  
  56.   line[i] = NULL;
  57. }
  58.  
  59. void
  60. FreeList(listArr)
  61.      XtPointer       listArr[];
  62. {
  63.   int             i;
  64.  
  65.   for (i = 0; listArr[i]; i++)
  66.     XtFree(listArr[i]);
  67.  
  68.   listArr[0] = NULL;
  69. }
  70.  
  71. int
  72. ConvertStringToIntArray(str, intArr)
  73.      char *str;
  74.      int  intArr[];
  75. {
  76.   char num[TIN_BUF], *numPtr;
  77.   int i;
  78.   
  79.   intArr[0] = 0;
  80.  
  81.   if (!str) return 0;
  82.  
  83.   for (i = 0;;) {
  84.     while (isspace(*str)) str++;
  85.     if (!*str) return 0;
  86.  
  87.     for (numPtr = num; *str && !isspace(*str); *numPtr++ = *str++);
  88.     *numPtr = '\0';
  89.     intArr[i] = atoi(num);
  90.     intArr[++i] = 0;
  91.   }
  92. }
  93.  
  94. /* ------------------------------------------------------------
  95.  * Routines to read from the tty.
  96.  */
  97.  
  98. /*
  99.  * TtyReadStr: reads a bunch of characters from the modem.
  100.  */
  101.  
  102. int
  103. TtyReadStr(fd, buf)
  104.      int             fd;
  105.      char           *buf;
  106. {
  107.   int      count;
  108.  
  109.   /* The do-loop is used to restart the system call if it is interrupted by 
  110.      a signal. This is simpler than missing with SA_INTERRUPT */
  111.   do
  112.     /* BUFSIZ is defined in stdio.h */
  113.     count = read(fd, buf, BUFSIZ);
  114.   while (count < 0 && errno ==  EINTR);
  115.  
  116.   if (count < 0) {
  117.     SePError("character read"); 
  118.     return -1;
  119.   }
  120.  
  121.   return count;
  122. }
  123.  
  124. jmp_buf         timedReadEnv;
  125.  
  126. void
  127. timedReadAlarmHandler(dummy)
  128.      int             dummy;
  129. {
  130.   longjmp(timedReadEnv, 1);
  131. }
  132.  
  133. int
  134. TtyTimedReadChar(fd, readChar, expireTime)
  135.      int             fd;
  136.      char           *readChar;
  137.      int             expireTime;
  138. {
  139.   /* BUFSIZ is defined in stdio.h */
  140.   static char     readBuf[BUFSIZ],
  141.                  *bufPtr;
  142.   static int      count = 0;
  143.   static void     (*oldSigHandler)();
  144.   static unsigned oldAlarmTimeLeft;
  145.  
  146.   if (count > 0) {
  147.     count--;
  148.     *readChar = *++bufPtr;
  149.     return 0;
  150.   }
  151.  
  152.   if (expireTime > 0) {
  153.     oldSigHandler = signal(SIGALRM, timedReadAlarmHandler);
  154.     oldAlarmTimeLeft = alarm((unsigned)expireTime);
  155.  
  156.     if (setjmp(timedReadEnv) != 0) {
  157.       alarm(max(oldAlarmTimeLeft - expireTime, 0));
  158.       signal(SIGALRM, oldSigHandler);
  159.       return -1;
  160.     }
  161.   }
  162.  
  163.   count = TtyReadStr(fd, (bufPtr = readBuf));
  164.  
  165.   if (expireTime > 0) {
  166.     alarm(max(oldAlarmTimeLeft - expireTime + alarm(0), 0));
  167.     signal(SIGALRM, oldSigHandler);
  168.   }
  169.  
  170.   if (count < 0) return count;
  171.  
  172.   count--;
  173.   *readChar = *bufPtr;
  174.  
  175.   return 0;
  176. }
  177.  
  178. /*
  179.  * TtyReadChar: reads one character from the tty.
  180.  */
  181.  
  182. char
  183. TtyReadChar(fd, readChar)
  184.      int             fd;
  185.      char           *readChar;
  186. {
  187.   return TtyTimedReadChar(fd, readChar, 0);
  188. }
  189.  
  190. /*---------------------------------------------------------------------------+
  191. | TtyReadLine: reads one line from the tty.
  192. +---------------------------------------------------------------------------*/
  193.  
  194. int
  195. TtyReadLine(fd, buf)
  196.      int             fd;
  197.      char           *buf;
  198. {
  199.   char            c;
  200.   int             i, readCharRet;
  201.  
  202.   while ((readCharRet = TtyReadChar(fd, &c)) >= 0 && (c == '\r' || c == '\n'));
  203.   if (readCharRet < 0) return readCharRet;
  204.  
  205.   i = 0;
  206.   do buf[i++] = c;
  207.   while ((readCharRet = TtyReadChar(fd, &c)) >=0 && (c != '\r' && c != '\n'));
  208.   
  209.   buf[i] = '\0';
  210.   return readCharRet;
  211. }
  212.  
  213. int
  214. TtyTimedWaitFor(fd, expectedString, waitTime)
  215.      int             fd;
  216.      char           *expectedString;
  217.      int             waitTime;
  218. {
  219.   time_t          expireTime;
  220.   char            c, *ptr = expectedString;
  221.  
  222.   expireTime = time((time_t*)0) + waitTime;
  223.  
  224.   while (expireTime != time((time_t*)0)) {
  225.     if ((TtyTimedReadChar(fd, &c, 1)) < 0)
  226.       continue;
  227.  
  228.     if ((char)c != *ptr) ptr = expectedString;
  229.     else if (*++ptr == '\0') return 0;
  230.   } /* while... */
  231.  
  232.   return -1;
  233. }
  234.  
  235. /* ------------------------------------------------------------
  236.  * Miscellaneous routines.
  237.  */
  238.  
  239. /*
  240.  * usleep: for systems that do not have it.
  241.  */
  242.  
  243. #if !HAVE_USLEEP
  244. void
  245. usleep(usec)
  246.      unsigned long usec;
  247. {
  248. #if HAVE_SELECT
  249.  
  250.   /* Orest Zborowski originally wrote this */
  251.  
  252.   struct timeval  timeout;
  253.  
  254.   timeout.tv_sec = usec / 1000000;
  255.   timeout.tv_usec = usec - 1000000 * timeout.tv_sec;
  256.   select(1, NULL, NULL, NULL, &timeout);
  257. #else
  258.  
  259. /* This busy-waiting, normally a bad idea on a multi-tasking system, is used
  260.    because sleep(1) is way too much of a delay. */
  261.  
  262.   int             i;
  263.  
  264.   for (i = 0; i < usec; i++);
  265. #endif /* HAVE_SELECT */
  266. }
  267. #endif /* HAVE_USLEEP */
  268.  
  269. /* 
  270.  * dup2: for systems that do not have it.
  271.  */
  272.  
  273. #if !HAVE_DUP2
  274. int
  275. dup2(oldfd, newfd)
  276.      int             oldfd,
  277.                      newfd;
  278. {
  279.   if (fcntl(oldfd, F_GETFL, 0) == -1)    /* Valid file descriptor? */
  280.     return (-1);           /* No, return an error. */
  281.   close(newfd);               /* Ensure newfd is closed */
  282.   return (fcntl(oldfd, F_DUPFD, newfd));    /* Dup oldfd into newfd */
  283. }
  284.  
  285. #endif /* HAVE_DUP2  Thanks to Bill Allie CIS: 76703,2061 */
  286.